home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / GCC 1.37.1r14 / usr / gcc-1.37.1r14 / non-obj files / cexp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-20  |  38.4 KB  |  1,469 lines  |  [TEXT/KAHL]
  1.  
  2. /*  A Bison parser, made from ./cexp.y  */
  3.  
  4. #define    INT    258
  5. #define    CHAR    259
  6. #define    NAME    260
  7. #define    ERROR    261
  8. #define    OR    262
  9. #define    AND    263
  10. #define    EQUAL    264
  11. #define    NOTEQUAL    265
  12. #define    LEQ    266
  13. #define    GEQ    267
  14. #define    LSH    268
  15. #define    RSH    269
  16. #define    UNARY    270
  17.  
  18. #line 26 "./cexp.y"
  19.  
  20. #include "config.h"
  21. #include <setjmp.h>
  22. /* #define YYDEBUG 1 */
  23.  
  24.   int yylex ();
  25.   void yyerror ();
  26.   int expression_value;
  27.  
  28.   static jmp_buf parse_return_error;
  29.  
  30.   /* some external tables of character types */
  31.   extern unsigned char is_idstart[], is_idchar[];
  32.  
  33. #ifndef CHAR_TYPE_SIZE
  34. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  35. #endif
  36.  
  37. #line 45 "./cexp.y"
  38. typedef union {
  39.   struct constant {long value; int unsignedp;} integer;
  40.   int voidval;
  41.   char *sval;
  42. } YYSTYPE;
  43.  
  44. #ifndef YYLTYPE
  45. typedef
  46.   struct yyltype
  47.     {
  48.       int timestamp;
  49.       int first_line;
  50.       int first_column;
  51.       int last_line;
  52.       int last_column;
  53.       char *text;
  54.    }
  55.   yyltype;
  56.  
  57. #define YYLTYPE yyltype
  58. #endif
  59.  
  60. #include <stdio.h>
  61.  
  62. #ifndef __STDC__
  63. #define const
  64. #endif
  65.  
  66.  
  67.  
  68. #define    YYFINAL        61
  69. #define    YYFLAG        -32768
  70. #define    YYNTBASE    33
  71.  
  72. #define YYTRANSLATE(x) ((unsigned)(x) <= 270 ? yytranslate[x] : 36)
  73.  
  74. static const char yytranslate[] = {     0,
  75.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  76.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  77.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  78.      2,     2,    29,     2,     2,     2,    27,    14,     2,    31,
  79.     32,    25,    23,     9,    24,     2,    26,     2,     2,     2,
  80.      2,     2,     2,     2,     2,     2,     2,     8,     2,    17,
  81.      2,    18,     7,     2,     2,     2,     2,     2,     2,     2,
  82.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  83.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  84.      2,     2,     2,    13,     2,     2,     2,     2,     2,     2,
  85.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  86.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  87.      2,     2,     2,    12,     2,    30,     2,     2,     2,     2,
  88.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  89.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  90.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  91.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  92.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  93.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  94.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  95.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  96.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  97.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  98.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  99.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  100.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  101.      6,    10,    11,    15,    16,    19,    20,    21,    22,    28
  102. };
  103.  
  104. static const short yyprhs[] = {     0,
  105.      0,     2,     4,     8,    11,    14,    17,    20,    24,    28,
  106.     32,    36,    40,    44,    48,    52,    56,    60,    64,    68,
  107.     72,    76,    80,    84,    88,    92,    96,   102,   104,   106
  108. };
  109.  
  110. static const short yyrhs[] = {    34,
  111.      0,    35,     0,    34,     9,    35,     0,    24,    35,     0,
  112.     29,    35,     0,    23,    35,     0,    30,    35,     0,    31,
  113.     34,    32,     0,    35,    25,    35,     0,    35,    26,    35,
  114.      0,    35,    27,    35,     0,    35,    23,    35,     0,    35,
  115.     24,    35,     0,    35,    21,    35,     0,    35,    22,    35,
  116.      0,    35,    15,    35,     0,    35,    16,    35,     0,    35,
  117.     19,    35,     0,    35,    20,    35,     0,    35,    17,    35,
  118.      0,    35,    18,    35,     0,    35,    14,    35,     0,    35,
  119.     13,    35,     0,    35,    12,    35,     0,    35,    11,    35,
  120.      0,    35,    10,    35,     0,    35,     7,    35,     8,    35,
  121.      0,     3,     0,     4,     0,     5,     0
  122. };
  123.  
  124. #if YYDEBUG != 0
  125. static const short yyrline[] = { 0,
  126.     74,    79,    80,    85,    88,    91,    93,    96,   101,   107,
  127.    118,   129,   132,   135,   141,   147,   150,   153,   159,   165,
  128.    171,   177,   180,   183,   186,   189,   192,   195,   197,   199
  129. };
  130.  
  131. static const char * const yytname[] = {   "$",
  132. "error","$illegal.","INT","CHAR","NAME","ERROR","'?'","':'","','","OR",
  133. "AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'","'>'","LEQ","GEQ",
  134. "LSH","RSH","'+'","'-'","'*'","'/'","'%'","UNARY","'!'","'~'",
  135. "'('","')'","start","exp1","exp",""
  136. };
  137. #endif
  138.  
  139. static const short yyr1[] = {     0,
  140.     33,    34,    34,    35,    35,    35,    35,    35,    35,    35,
  141.     35,    35,    35,    35,    35,    35,    35,    35,    35,    35,
  142.     35,    35,    35,    35,    35,    35,    35,    35,    35,    35
  143. };
  144.  
  145. static const short yyr2[] = {     0,
  146.      1,     1,     3,     2,     2,     2,     2,     3,     3,     3,
  147.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  148.      3,     3,     3,     3,     3,     3,     5,     1,     1,     1
  149. };
  150.  
  151. static const short yydefact[] = {     0,
  152.     28,    29,    30,     0,     0,     0,     0,     0,     1,     2,
  153.      6,     4,     5,     7,     0,     0,     0,     0,     0,     0,
  154.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  155.      0,     0,     0,     0,     0,     8,     3,     0,    26,    25,
  156.     24,    23,    22,    16,    17,    20,    21,    18,    19,    14,
  157.     15,    12,    13,     9,    10,    11,     0,    27,     0,     0,
  158.      0
  159. };
  160.  
  161. static const short yydefgoto[] = {    59,
  162.      9,    10
  163. };
  164.  
  165. static const short yypact[] = {    31,
  166. -32768,-32768,-32768,    31,    31,    31,    31,    31,     1,    77,
  167. -32768,-32768,-32768,-32768,     0,    31,    31,    31,    31,    31,
  168.     31,    31,    31,    31,    31,    31,    31,    31,    31,    31,
  169.     31,    31,    31,    31,    31,-32768,    77,    56,    94,    25,
  170.    109,   123,   136,   147,   147,   154,   154,   154,   154,   -19,
  171.    -19,    32,    32,-32768,-32768,-32768,    31,    77,    11,    33,
  172. -32768
  173. };
  174.  
  175. static const short yypgoto[] = {-32768,
  176.     48,    -4
  177. };
  178.  
  179.  
  180. #define    YYLAST        181
  181.  
  182.  
  183. static const short yytable[] = {    11,
  184.     12,    13,    14,    31,    32,    33,    34,    35,    16,    16,
  185.     60,    37,    38,    39,    40,    41,    42,    43,    44,    45,
  186.     46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
  187.     56,    36,    61,     1,     2,     3,    20,    21,    22,    23,
  188.     24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
  189.     34,    35,    58,     4,     5,    15,    33,    34,    35,     6,
  190.      7,     8,    17,    57,     0,    18,    19,    20,    21,    22,
  191.     23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
  192.     33,    34,    35,    17,     0,     0,    18,    19,    20,    21,
  193.     22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
  194.     32,    33,    34,    35,    19,    20,    21,    22,    23,    24,
  195.     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  196.     35,    21,    22,    23,    24,    25,    26,    27,    28,    29,
  197.     30,    31,    32,    33,    34,    35,    22,    23,    24,    25,
  198.     26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  199.     23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
  200.     33,    34,    35,    25,    26,    27,    28,    29,    30,    31,
  201.     32,    33,    34,    35,    29,    30,    31,    32,    33,    34,
  202.     35
  203. };
  204.  
  205. static const short yycheck[] = {     4,
  206.      5,     6,     7,    23,    24,    25,    26,    27,     9,     9,
  207.      0,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  208.     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  209.     35,    32,     0,     3,     4,     5,    12,    13,    14,    15,
  210.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  211.     26,    27,    57,    23,    24,     8,    25,    26,    27,    29,
  212.     30,    31,     7,     8,    -1,    10,    11,    12,    13,    14,
  213.     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  214.     25,    26,    27,     7,    -1,    -1,    10,    11,    12,    13,
  215.     14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
  216.     24,    25,    26,    27,    11,    12,    13,    14,    15,    16,
  217.     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
  218.     27,    13,    14,    15,    16,    17,    18,    19,    20,    21,
  219.     22,    23,    24,    25,    26,    27,    14,    15,    16,    17,
  220.     18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
  221.     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  222.     25,    26,    27,    17,    18,    19,    20,    21,    22,    23,
  223.     24,    25,    26,    27,    21,    22,    23,    24,    25,    26,
  224.     27
  225. };
  226. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  227. #line 3 "bison.simple"
  228.  
  229. /* Skeleton output parser for bison,
  230.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  231.  
  232.    This program is free software; you can redistribute it and/or modify
  233.    it under the terms of the GNU General Public License as published by
  234.    the Free Software Foundation; either version 1, or (at your option)
  235.    any later version.
  236.  
  237.    This program is distributed in the hope that it will be useful,
  238.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  239.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  240.    GNU General Public License for more details.
  241.  
  242.    You should have received a copy of the GNU General Public License
  243.    along with this program; if not, write to the Free Software
  244.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  245.  
  246.  
  247. #ifndef alloca
  248. #ifdef __GNUC__
  249. #define alloca __builtin_alloca
  250. #else /* Not GNU C.  */
  251. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  252. #include <alloca.h>
  253. #else /* Not sparc */
  254. #ifdef MSDOS
  255. #include <malloc.h>
  256. #endif /* MSDOS */
  257. #endif /* Not sparc.  */
  258. #endif /* Not GNU C.  */
  259. #endif /* alloca not defined.  */
  260.  
  261. /* This is the parser code that is written into each bison parser
  262.   when the %semantic_parser declaration is not specified in the grammar.
  263.   It was written by Richard Stallman by simplifying the hairy parser
  264.   used when %semantic_parser is specified.  */
  265.  
  266. /* Note: there must be only one dollar sign in this file.
  267.    It is replaced by the list of actions, each action
  268.    as one case of the switch.  */
  269.  
  270. #define yyerrok        (yyerrstatus = 0)
  271. #define yyclearin    (yychar = YYEMPTY)
  272. #define YYEMPTY        -2
  273. #define YYEOF        0
  274. #define YYACCEPT    return(0)
  275. #define YYABORT     return(1)
  276. #define YYERROR        goto yyerrlab1
  277. /* Like YYERROR except do call yyerror.
  278.    This remains here temporarily to ease the
  279.    transition to the new meaning of YYERROR, for GCC.
  280.    Once GCC version 2 has supplanted version 1, this can go.  */
  281. #define YYFAIL        goto yyerrlab
  282. #define YYRECOVERING()  (!!yyerrstatus)
  283. #define YYBACKUP(token, value) \
  284. do                                \
  285.   if (yychar == YYEMPTY && yylen == 1)                \
  286.     { yychar = (token), yylval = (value);            \
  287.       yychar1 = YYTRANSLATE (yychar);                \
  288.       YYPOPSTACK;                        \
  289.       goto yybackup;                        \
  290.     }                                \
  291.   else                                \
  292.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  293. while (0)
  294.  
  295. #define YYTERROR    1
  296. #define YYERRCODE    256
  297.  
  298. #ifndef YYPURE
  299. #define YYLEX        yylex()
  300. #endif
  301.  
  302. #ifdef YYPURE
  303. #ifdef YYLSP_NEEDED
  304. #define YYLEX        yylex(&yylval, &yylloc)
  305. #else
  306. #define YYLEX        yylex(&yylval)
  307. #endif
  308. #endif
  309.  
  310. /* If nonreentrant, generate the variables here */
  311.  
  312. #ifndef YYPURE
  313.  
  314. int    yychar;            /*  the lookahead symbol        */
  315. YYSTYPE    yylval;            /*  the semantic value of the        */
  316.                 /*  lookahead symbol            */
  317.  
  318. #ifdef YYLSP_NEEDED
  319. YYLTYPE yylloc;            /*  location data for the lookahead    */
  320.                 /*  symbol                */
  321. #endif
  322.  
  323. int yynerrs;            /*  number of parse errors so far       */
  324. #endif  /* not YYPURE */
  325.  
  326. #if YYDEBUG != 0
  327. int yydebug;            /*  nonzero means print parse trace    */
  328. /* Since this is uninitialized, it does not stop multiple parsers
  329.    from coexisting.  */
  330. #endif
  331.  
  332. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  333.  
  334. #ifndef    YYINITDEPTH
  335. #define YYINITDEPTH 200
  336. #endif
  337.  
  338. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  339.     (effective only if the built-in stack extension method is used).  */
  340.  
  341. #if YYMAXDEPTH == 0
  342. #undef YYMAXDEPTH
  343. #endif
  344.  
  345. #ifndef YYMAXDEPTH
  346. #define YYMAXDEPTH 10000
  347. #endif
  348.  
  349. #ifndef __cplusplus
  350.  
  351. /* This is the most reliable way to avoid incompatibilities
  352.    in available built-in functions on various systems.  */
  353. static void
  354. __yy_bcopy (from, to, count)
  355.      char *from;
  356.      char *to;
  357.      int count;
  358. {
  359.   register char *f = from;
  360.   register char *t = to;
  361.   register int i = count;
  362.  
  363.   while (i-- > 0)
  364.     *t++ = *f++;
  365. }
  366.  
  367. #else /* __cplusplus */
  368.  
  369. /* This is the most reliable way to avoid incompatibilities
  370.    in available built-in functions on various systems.  */
  371. static void
  372. __yy_bcopy (char *from, char *to, int count)
  373. {
  374.   register char *f = from;
  375.   register char *t = to;
  376.   register int i = count;
  377.  
  378.   while (i-- > 0)
  379.     *t++ = *f++;
  380. }
  381.  
  382. #endif
  383.  
  384. #line 160 "bison.simple"
  385. int
  386. yyparse()
  387. {
  388.   register int yystate;
  389.   register int yyn;
  390.   register short *yyssp;
  391.   register YYSTYPE *yyvsp;
  392.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  393.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  394.  
  395.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  396.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  397.  
  398.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  399.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  400.  
  401. #ifdef YYLSP_NEEDED
  402.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  403.   YYLTYPE *yyls = yylsa;
  404.   YYLTYPE *yylsp;
  405.  
  406. #define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
  407. #else
  408. #define YYPOPSTACK   (yyvsp--, yysp--)
  409. #endif
  410.  
  411.   int yystacksize = YYINITDEPTH;
  412.  
  413. #ifdef YYPURE
  414.   int yychar;
  415.   YYSTYPE yylval;
  416.   int yynerrs;
  417. #ifdef YYLSP_NEEDED
  418.   YYLTYPE yylloc;
  419. #endif
  420. #endif
  421.  
  422.   YYSTYPE yyval;        /*  the variable used to return        */
  423.                 /*  semantic values from the action    */
  424.                 /*  routines                */
  425.  
  426.   int yylen;
  427.  
  428. #if YYDEBUG != 0
  429.   if (yydebug)
  430.     fprintf(stderr, "Starting parse\n");
  431. #endif
  432.  
  433.   yystate = 0;
  434.   yyerrstatus = 0;
  435.   yynerrs = 0;
  436.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  437.  
  438.   /* Initialize stack pointers.
  439.      Waste one element of value and location stack
  440.      so that they stay on the same level as the state stack.  */
  441.  
  442.   yyssp = yyss - 1;
  443.   yyvsp = yyvs;
  444. #ifdef YYLSP_NEEDED
  445.   yylsp = yyls;
  446. #endif
  447.  
  448. /* Push a new state, which is found in  yystate  .  */
  449. /* In all cases, when you get here, the value and location stacks
  450.    have just been pushed. so pushing a state here evens the stacks.  */
  451. yynewstate:
  452.  
  453.   *++yyssp = yystate;
  454.  
  455.   if (yyssp >= yyss + yystacksize - 1)
  456.     {
  457.       /* Give user a chance to reallocate the stack */
  458.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  459.       YYSTYPE *yyvs1 = yyvs;
  460.       short *yyss1 = yyss;
  461. #ifdef YYLSP_NEEDED
  462.       YYLTYPE *yyls1 = yyls;
  463. #endif
  464.  
  465.       /* Get the current used size of the three stacks, in elements.  */
  466.       int size = yyssp - yyss + 1;
  467.  
  468. #ifdef yyoverflow
  469.       /* Each stack pointer address is followed by the size of
  470.      the data in use in that stack, in bytes.  */
  471.       yyoverflow("parser stack overflow",
  472.          &yyss1, size * sizeof (*yyssp),
  473.          &yyvs1, size * sizeof (*yyvsp),
  474. #ifdef YYLSP_NEEDED
  475.          &yyls1, size * sizeof (*yylsp),
  476. #endif
  477.          &yystacksize);
  478.  
  479.       yyss = yyss1; yyvs = yyvs1;
  480. #ifdef YYLSP_NEEDED
  481.       yyls = yyls1;
  482. #endif
  483. #else /* no yyoverflow */
  484.       /* Extend the stack our own way.  */
  485.       if (yystacksize >= YYMAXDEPTH)
  486.     {
  487.       yyerror("parser stack overflow");
  488.       return 2;
  489.     }
  490.       yystacksize *= 2;
  491.       if (yystacksize > YYMAXDEPTH)
  492.     yystacksize = YYMAXDEPTH;
  493.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  494.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  495.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  496.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  497. #ifdef YYLSP_NEEDED
  498.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  499.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  500. #endif
  501. #endif /* no yyoverflow */
  502.  
  503.       yyssp = yyss + size - 1;
  504.       yyvsp = yyvs + size - 1;
  505. #ifdef YYLSP_NEEDED
  506.       yylsp = yyls + size - 1;
  507. #endif
  508.  
  509. #if YYDEBUG != 0
  510.       if (yydebug)
  511.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  512. #endif
  513.  
  514.       if (yyssp >= yyss + yystacksize - 1)
  515.     YYABORT;
  516.     }
  517.  
  518. #if YYDEBUG != 0
  519.   if (yydebug)
  520.     fprintf(stderr, "Entering state %d\n", yystate);
  521. #endif
  522.  
  523.  yybackup:
  524.  
  525. /* Do appropriate processing given the current state.  */
  526. /* Read a lookahead token if we need one and don't already have one.  */
  527. /* yyresume: */
  528.  
  529.   /* First try to decide what to do without reference to lookahead token.  */
  530.  
  531.   yyn = yypact[yystate];
  532.   if (yyn == YYFLAG)
  533.     goto yydefault;
  534.  
  535.   /* Not known => get a lookahead token if don't already have one.  */
  536.  
  537.   /* yychar is either YYEMPTY or YYEOF
  538.      or a valid token in external form.  */
  539.  
  540.   if (yychar == YYEMPTY)
  541.     {
  542. #if YYDEBUG != 0
  543.       if (yydebug)
  544.     fprintf(stderr, "Reading a token: ");
  545. #endif
  546.       yychar = YYLEX;
  547.     }
  548.  
  549.   /* Convert token to internal form (in yychar1) for indexing tables with */
  550.  
  551.   if (yychar <= 0)        /* This means end of input. */
  552.     {
  553.       yychar1 = 0;
  554.       yychar = YYEOF;        /* Don't call YYLEX any more */
  555.  
  556. #if YYDEBUG != 0
  557.       if (yydebug)
  558.     fprintf(stderr, "Now at end of input.\n");
  559. #endif
  560.     }
  561.   else
  562.     {
  563.       yychar1 = YYTRANSLATE(yychar);
  564.  
  565. #if YYDEBUG != 0
  566.       if (yydebug)
  567.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  568. #endif
  569.     }
  570.  
  571.   yyn += yychar1;
  572.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  573.     goto yydefault;
  574.  
  575.   yyn = yytable[yyn];
  576.  
  577.   /* yyn is what to do for this token type in this state.
  578.      Negative => reduce, -yyn is rule number.
  579.      Positive => shift, yyn is new state.
  580.        New state is final state => don't bother to shift,
  581.        just return success.
  582.      0, or most negative number => error.  */
  583.  
  584.   if (yyn < 0)
  585.     {
  586.       if (yyn == YYFLAG)
  587.     goto yyerrlab;
  588.       yyn = -yyn;
  589.       goto yyreduce;
  590.     }
  591.   else if (yyn == 0)
  592.     goto yyerrlab;
  593.  
  594.   if (yyn == YYFINAL)
  595.     YYACCEPT;
  596.  
  597.   /* Shift the lookahead token.  */
  598.  
  599. #if YYDEBUG != 0
  600.   if (yydebug)
  601.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  602. #endif
  603.  
  604.   /* Discard the token being shifted unless it is eof.  */
  605.   if (yychar != YYEOF)
  606.     yychar = YYEMPTY;
  607.  
  608.   *++yyvsp = yylval;
  609. #ifdef YYLSP_NEEDED
  610.   *++yylsp = yylloc;
  611. #endif
  612.  
  613.   /* count tokens shifted since error; after three, turn off error status.  */
  614.   if (yyerrstatus) yyerrstatus--;
  615.  
  616.   yystate = yyn;
  617.   goto yynewstate;
  618.  
  619. /* Do the default action for the current state.  */
  620. yydefault:
  621.  
  622.   yyn = yydefact[yystate];
  623.   if (yyn == 0)
  624.     goto yyerrlab;
  625.  
  626. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  627. yyreduce:
  628.   yylen = yyr2[yyn];
  629.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  630.  
  631. #if YYDEBUG != 0
  632.   if (yydebug)
  633.     {
  634.       int i;
  635.  
  636.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  637.            yyn, yyrline[yyn]);
  638.  
  639.       /* Print the symboles being reduced, and their result.  */
  640.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  641.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  642.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  643.     }
  644. #endif
  645.  
  646.  
  647.   switch (yyn) {
  648.  
  649. case 1:
  650. #line 75 "./cexp.y"
  651. { expression_value = yyvsp[0].integer.value; ;
  652.     break;}
  653. case 3:
  654. #line 81 "./cexp.y"
  655. { yyval.integer = yyvsp[0].integer; ;
  656.     break;}
  657. case 4:
  658. #line 86 "./cexp.y"
  659. { yyval.integer.value = - yyvsp[0].integer.value;
  660.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  661.     break;}
  662. case 5:
  663. #line 89 "./cexp.y"
  664. { yyval.integer.value = ! yyvsp[0].integer.value;
  665.               yyval.integer.unsignedp = 0; ;
  666.     break;}
  667. case 6:
  668. #line 92 "./cexp.y"
  669. { yyval.integer = yyvsp[0].integer; ;
  670.     break;}
  671. case 7:
  672. #line 94 "./cexp.y"
  673. { yyval.integer.value = ~ yyvsp[0].integer.value;
  674.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  675.     break;}
  676. case 8:
  677. #line 97 "./cexp.y"
  678. { yyval.integer = yyvsp[-1].integer; ;
  679.     break;}
  680. case 9:
  681. #line 102 "./cexp.y"
  682. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  683.               if (yyval.integer.unsignedp)
  684.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value * yyvsp[0].integer.value;
  685.               else
  686.                 yyval.integer.value = yyvsp[-2].integer.value * yyvsp[0].integer.value; ;
  687.     break;}
  688. case 10:
  689. #line 108 "./cexp.y"
  690. { if (yyvsp[0].integer.value == 0)
  691.                 {
  692.                   error ("division by zero in #if");
  693.                   yyvsp[0].integer.value = 1;
  694.                 }
  695.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  696.               if (yyval.integer.unsignedp)
  697.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value / yyvsp[0].integer.value;
  698.               else
  699.                 yyval.integer.value = yyvsp[-2].integer.value / yyvsp[0].integer.value; ;
  700.     break;}
  701. case 11:
  702. #line 119 "./cexp.y"
  703. { if (yyvsp[0].integer.value == 0)
  704.                 {
  705.                   error ("division by zero in #if");
  706.                   yyvsp[0].integer.value = 1;
  707.                 }
  708.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  709.               if (yyval.integer.unsignedp)
  710.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value % yyvsp[0].integer.value;
  711.               else
  712.                 yyval.integer.value = yyvsp[-2].integer.value % yyvsp[0].integer.value; ;
  713.     break;}
  714. case 12:
  715. #line 130 "./cexp.y"
  716. { yyval.integer.value = yyvsp[-2].integer.value + yyvsp[0].integer.value;
  717.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  718.     break;}
  719. case 13:
  720. #line 133 "./cexp.y"
  721. { yyval.integer.value = yyvsp[-2].integer.value - yyvsp[0].integer.value;
  722.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  723.     break;}
  724. case 14:
  725. #line 136 "./cexp.y"
  726. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  727.               if (yyval.integer.unsignedp)
  728.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value << yyvsp[0].integer.value;
  729.               else
  730.                 yyval.integer.value = yyvsp[-2].integer.value << yyvsp[0].integer.value; ;
  731.     break;}
  732. case 15:
  733. #line 142 "./cexp.y"
  734. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  735.               if (yyval.integer.unsignedp)
  736.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value >> yyvsp[0].integer.value;
  737.               else
  738.                 yyval.integer.value = yyvsp[-2].integer.value >> yyvsp[0].integer.value; ;
  739.     break;}
  740. case 16:
  741. #line 148 "./cexp.y"
  742. { yyval.integer.value = (yyvsp[-2].integer.value == yyvsp[0].integer.value);
  743.               yyval.integer.unsignedp = 0; ;
  744.     break;}
  745. case 17:
  746. #line 151 "./cexp.y"
  747. { yyval.integer.value = (yyvsp[-2].integer.value != yyvsp[0].integer.value);
  748.               yyval.integer.unsignedp = 0; ;
  749.     break;}
  750. case 18:
  751. #line 154 "./cexp.y"
  752. { yyval.integer.unsignedp = 0;
  753.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  754.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value <= yyvsp[0].integer.value;
  755.               else
  756.                 yyval.integer.value = yyvsp[-2].integer.value <= yyvsp[0].integer.value; ;
  757.     break;}
  758. case 19:
  759. #line 160 "./cexp.y"
  760. { yyval.integer.unsignedp = 0;
  761.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  762.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value >= yyvsp[0].integer.value;
  763.               else
  764.                 yyval.integer.value = yyvsp[-2].integer.value >= yyvsp[0].integer.value; ;
  765.     break;}
  766. case 20:
  767. #line 166 "./cexp.y"
  768. { yyval.integer.unsignedp = 0;
  769.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  770.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value < yyvsp[0].integer.value;
  771.               else
  772.                 yyval.integer.value = yyvsp[-2].integer.value < yyvsp[0].integer.value; ;
  773.     break;}
  774. case 21:
  775. #line 172 "./cexp.y"
  776. { yyval.integer.unsignedp = 0;
  777.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  778.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value > yyvsp[0].integer.value;
  779.               else
  780.                 yyval.integer.value = yyvsp[-2].integer.value > yyvsp[0].integer.value; ;
  781.     break;}
  782. case 22:
  783. #line 178 "./cexp.y"
  784. { yyval.integer.value = yyvsp[-2].integer.value & yyvsp[0].integer.value;
  785.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  786.     break;}
  787. case 23:
  788. #line 181 "./cexp.y"
  789. { yyval.integer.value = yyvsp[-2].integer.value ^ yyvsp[0].integer.value;
  790.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  791.     break;}
  792. case 24:
  793. #line 184 "./cexp.y"
  794. { yyval.integer.value = yyvsp[-2].integer.value | yyvsp[0].integer.value;
  795.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  796.     break;}
  797. case 25:
  798. #line 187 "./cexp.y"
  799. { yyval.integer.value = (yyvsp[-2].integer.value && yyvsp[0].integer.value);
  800.               yyval.integer.unsignedp = 0; ;
  801.     break;}
  802. case 26:
  803. #line 190 "./cexp.y"
  804. { yyval.integer.value = (yyvsp[-2].integer.value || yyvsp[0].integer.value);
  805.               yyval.integer.unsignedp = 0; ;
  806.     break;}
  807. case 27:
  808. #line 193 "./cexp.y"
  809. { yyval.integer.value = yyvsp[-4].integer.value ? yyvsp[-2].integer.value : yyvsp[0].integer.value;
  810.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  811.     break;}
  812. case 28:
  813. #line 196 "./cexp.y"
  814. { yyval.integer = yylval.integer; ;
  815.     break;}
  816. case 29:
  817. #line 198 "./cexp.y"
  818. { yyval.integer = yylval.integer; ;
  819.     break;}
  820. case 30:
  821. #line 200 "./cexp.y"
  822. { yyval.integer.value = 0;
  823.               yyval.integer.unsignedp = 0; ;
  824.     break;}
  825. }
  826.    /* the action file gets copied in in place of this dollarsign */
  827. #line 423 "bison.simple"
  828.  
  829.   yyvsp -= yylen;
  830.   yyssp -= yylen;
  831. #ifdef YYLSP_NEEDED
  832.   yylsp -= yylen;
  833. #endif
  834.  
  835. #if YYDEBUG != 0
  836.   if (yydebug)
  837.     {
  838.       short *ssp1 = yyss - 1;
  839.       fprintf (stderr, "state stack now");
  840.       while (ssp1 != yyssp)
  841.     fprintf (stderr, " %d", *++ssp1);
  842.       fprintf (stderr, "\n");
  843.     }
  844. #endif
  845.  
  846.   *++yyvsp = yyval;
  847.  
  848. #ifdef YYLSP_NEEDED
  849.   yylsp++;
  850.   if (yylen == 0)
  851.     {
  852.       yylsp->first_line = yylloc.first_line;
  853.       yylsp->first_column = yylloc.first_column;
  854.       yylsp->last_line = (yylsp-1)->last_line;
  855.       yylsp->last_column = (yylsp-1)->last_column;
  856.       yylsp->text = 0;
  857.     }
  858.   else
  859.     {
  860.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  861.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  862.     }
  863. #endif
  864.  
  865.   /* Now "shift" the result of the reduction.
  866.      Determine what state that goes to,
  867.      based on the state we popped back to
  868.      and the rule number reduced by.  */
  869.  
  870.   yyn = yyr1[yyn];
  871.  
  872.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  873.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  874.     yystate = yytable[yystate];
  875.   else
  876.     yystate = yydefgoto[yyn - YYNTBASE];
  877.  
  878.   goto yynewstate;
  879.  
  880. yyerrlab:   /* here on detecting error */
  881.  
  882.   if (! yyerrstatus)
  883.     /* If not already recovering from an error, report this error.  */
  884.     {
  885.       ++yynerrs;
  886.  
  887. #ifdef YYERROR_VERBOSE
  888.       yyn = yypact[yystate];
  889.  
  890.       if (yyn > YYFLAG && yyn < YYLAST)
  891.     {
  892.       int size = 0;
  893.       char *msg;
  894.       int x, count;
  895.  
  896.       count = 0;
  897.       for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  898.         if (yycheck[x + yyn] == x)
  899.           size += strlen(yytname[x]) + 15, count++;
  900.       msg = (char *) xmalloc(size + 15);
  901.       strcpy(msg, "parse error");
  902.  
  903.       if (count < 5)
  904.         {
  905.           count = 0;
  906.           for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  907.         if (yycheck[x + yyn] == x)
  908.           {
  909.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  910.             strcat(msg, yytname[x]);
  911.             strcat(msg, "'");
  912.             count++;
  913.           }
  914.         }
  915.       yyerror(msg);
  916.       free(msg);
  917.     }
  918.       else
  919. #endif /* YYERROR_VERBOSE */
  920.     yyerror("parse error");
  921.     }
  922.  
  923. yyerrlab1:   /* here on error raised explicitly by an action */
  924.  
  925.   if (yyerrstatus == 3)
  926.     {
  927.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  928.  
  929.       /* return failure if at end of input */
  930.       if (yychar == YYEOF)
  931.     YYABORT;
  932.  
  933. #if YYDEBUG != 0
  934.       if (yydebug)
  935.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  936. #endif
  937.  
  938.       yychar = YYEMPTY;
  939.     }
  940.  
  941.   /* Else will try to reuse lookahead token
  942.      after shifting the error token.  */
  943.  
  944.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  945.  
  946.   goto yyerrhandle;
  947.  
  948. yyerrdefault:  /* current state does not do anything special for the error token. */
  949.  
  950. #if 0
  951.   /* This is wrong; only states that explicitly want error tokens
  952.      should shift them.  */
  953.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  954.   if (yyn) goto yydefault;
  955. #endif
  956.  
  957. yyerrpop:   /* pop the current state because it cannot handle the error token */
  958.  
  959.   if (yyssp == yyss) YYABORT;
  960.   yyvsp--;
  961.   yystate = *--yyssp;
  962. #ifdef YYLSP_NEEDED
  963.   yylsp--;
  964. #endif
  965.  
  966. #if YYDEBUG != 0
  967.   if (yydebug)
  968.     {
  969.       short *ssp1 = yyss - 1;
  970.       fprintf (stderr, "Error: state stack now");
  971.       while (ssp1 != yyssp)
  972.     fprintf (stderr, " %d", *++ssp1);
  973.       fprintf (stderr, "\n");
  974.     }
  975. #endif
  976.  
  977. yyerrhandle:
  978.  
  979.   yyn = yypact[yystate];
  980.   if (yyn == YYFLAG)
  981.     goto yyerrdefault;
  982.  
  983.   yyn += YYTERROR;
  984.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  985.     goto yyerrdefault;
  986.  
  987.   yyn = yytable[yyn];
  988.   if (yyn < 0)
  989.     {
  990.       if (yyn == YYFLAG)
  991.     goto yyerrpop;
  992.       yyn = -yyn;
  993.       goto yyreduce;
  994.     }
  995.   else if (yyn == 0)
  996.     goto yyerrpop;
  997.  
  998.   if (yyn == YYFINAL)
  999.     YYACCEPT;
  1000.  
  1001. #if YYDEBUG != 0
  1002.   if (yydebug)
  1003.     fprintf(stderr, "Shifting error token, ");
  1004. #endif
  1005.  
  1006.   *++yyvsp = yylval;
  1007. #ifdef YYLSP_NEEDED
  1008.   *++yylsp = yylloc;
  1009. #endif
  1010.  
  1011.   yystate = yyn;
  1012.   goto yynewstate;
  1013. }
  1014. #line 203 "./cexp.y"
  1015.  
  1016.  
  1017. /* During parsing of a C expression, the pointer to the next character
  1018.    is in this variable.  */
  1019.  
  1020. static char *lexptr;
  1021.  
  1022. /* Take care of parsing a number (anything that starts with a digit).
  1023.    Set yylval and return the token type; update lexptr.
  1024.    LEN is the number of characters in it.  */
  1025.  
  1026. /* maybe needs to actually deal with floating point numbers */
  1027.  
  1028. int
  1029. parse_number (olen)
  1030.      int olen;
  1031. {
  1032.   register char *p = lexptr;
  1033.   register long n = 0;
  1034.   register int c;
  1035.   register int base = 10;
  1036.   register int len = olen;
  1037.  
  1038.   for (c = 0; c < len; c++)
  1039.     if (p[c] == '.') {
  1040.       /* It's a float since it contains a point.  */
  1041.       yyerror ("floating point numbers not allowed in #if expressions");
  1042.       return ERROR;
  1043.     }
  1044.  
  1045.   yylval.integer.unsignedp = 0;
  1046.  
  1047.   if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
  1048.     p += 2;
  1049.     base = 16;
  1050.     len -= 2;
  1051.   }
  1052.   else if (*p == '0')
  1053.     base = 8;
  1054.  
  1055.   while (len > 0) {
  1056.     c = *p++;
  1057.     len--;
  1058.     if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
  1059.  
  1060.     if (c >= '0' && c <= '9') {
  1061.       n *= base;
  1062.       n += c - '0';
  1063.     } else if (base == 16 && c >= 'a' && c <= 'f') {
  1064.       n *= base;
  1065.       n += c - 'a' + 10;
  1066.     } else {
  1067.       /* `l' means long, and `u' means unsigned.  */
  1068.       while (1) {
  1069.     if (c == 'l' || c == 'L')
  1070.       ;
  1071.     else if (c == 'u' || c == 'U')
  1072.       yylval.integer.unsignedp = 1;
  1073.     else
  1074.       break;
  1075.  
  1076.     if (len == 0)
  1077.       break;
  1078.     c = *p++;
  1079.     len--;
  1080.       }
  1081.       /* Don't look for any more digits after the suffixes.  */
  1082.       break;
  1083.     }
  1084.   }
  1085.  
  1086.   if (len != 0) {
  1087.     yyerror ("Invalid number in #if expression");
  1088.     return ERROR;
  1089.   }
  1090.  
  1091.   /* If too big to be signed, consider it unsigned.  */
  1092.   if (n < 0)
  1093.     yylval.integer.unsignedp = 1;
  1094.  
  1095.   lexptr = p;
  1096.   yylval.integer.value = n;
  1097.   return INT;
  1098. }
  1099.  
  1100. struct token {
  1101.   char *operator;
  1102.   int token;
  1103. };
  1104.  
  1105. #ifndef NULL
  1106. #define NULL 0
  1107. #endif
  1108.  
  1109. static struct token tokentab2[] = {
  1110.   {"&&", AND},
  1111.   {"||", OR},
  1112.   {"<<", LSH},
  1113.   {">>", RSH},
  1114.   {"==", EQUAL},
  1115.   {"!=", NOTEQUAL},
  1116.   {"<=", LEQ},
  1117.   {">=", GEQ},
  1118.   {NULL, ERROR}
  1119. };
  1120.  
  1121. /* Read one token, getting characters through lexptr.  */
  1122.  
  1123. int
  1124. yylex ()
  1125. {
  1126.   register int c;
  1127.   register int namelen;
  1128.   register char *tokstart;
  1129.   register struct token *toktab;
  1130.  
  1131.  retry:
  1132.  
  1133.   tokstart = lexptr;
  1134.   c = *tokstart;
  1135.   /* See if it is a special token of length 2.  */
  1136.   for (toktab = tokentab2; toktab->operator != NULL; toktab++)
  1137.     if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
  1138.       lexptr += 2;
  1139.       return toktab->token;
  1140.     }
  1141.  
  1142.   switch (c) {
  1143.   case 0:
  1144.     return 0;
  1145.     
  1146.   case ' ':
  1147.   case '\t':
  1148.   case '\r':
  1149.   case '\n':
  1150.     lexptr++;
  1151.     goto retry;
  1152.     
  1153.   case '\'':
  1154.     lexptr++;
  1155.     c = *lexptr++;
  1156.     if (c == '\\')
  1157.       c = parse_escape (&lexptr);
  1158.  
  1159.     /* Sign-extend the constant if chars are signed on target machine.  */
  1160.     {
  1161.       if (lookup ("__CHAR_UNSIGNED__", sizeof ("__CHAR_UNSIGNED__")-1, -1)
  1162.       || ((c >> (CHAR_TYPE_SIZE - 1)) & 1) == 0)
  1163.     yylval.integer.value = c & ((1 << CHAR_TYPE_SIZE) - 1);
  1164.       else
  1165.     yylval.integer.value = c | ~((1 << CHAR_TYPE_SIZE) - 1);
  1166.     }
  1167.  
  1168.     yylval.integer.unsignedp = 0;
  1169.     c = *lexptr++;
  1170.     if (c != '\'') {
  1171.       yyerror ("Invalid character constant in #if");
  1172.       return ERROR;
  1173.     }
  1174.     
  1175.     return CHAR;
  1176.  
  1177.     /* some of these chars are invalid in constant expressions;
  1178.        maybe do something about them later */
  1179.   case '/':
  1180.   case '+':
  1181.   case '-':
  1182.   case '*':
  1183.   case '%':
  1184.   case '|':
  1185.   case '&':
  1186.   case '^':
  1187.   case '~':
  1188.   case '!':
  1189.   case '@':
  1190.   case '<':
  1191.   case '>':
  1192.   case '(':
  1193.   case ')':
  1194.   case '[':
  1195.   case ']':
  1196.   case '.':
  1197.   case '?':
  1198.   case ':':
  1199.   case '=':
  1200.   case '{':
  1201.   case '}':
  1202.   case ',':
  1203.     lexptr++;
  1204.     return c;
  1205.     
  1206.   case '"':
  1207.     yyerror ("double quoted strings not allowed in #if expressions");
  1208.     return ERROR;
  1209.   }
  1210.   if (c >= '0' && c <= '9') {
  1211.     /* It's a number */
  1212.     for (namelen = 0;
  1213.      c = tokstart[namelen], is_idchar[c] || c == '.'; 
  1214.      namelen++)
  1215.       ;
  1216.     return parse_number (namelen);
  1217.   }
  1218.   
  1219.   if (!is_idstart[c]) {
  1220.     yyerror ("Invalid token in expression");
  1221.     return ERROR;
  1222.   }
  1223.   
  1224.   /* It is a name.  See how long it is.  */
  1225.   
  1226.   for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
  1227.     ;
  1228.   
  1229.   lexptr += namelen;
  1230.   return NAME;
  1231. }
  1232.  
  1233.  
  1234. /* Parse a C escape sequence.  STRING_PTR points to a variable
  1235.    containing a pointer to the string to parse.  That pointer
  1236.    is updated past the characters we use.  The value of the
  1237.    escape sequence is returned.
  1238.  
  1239.    A negative value means the sequence \ newline was seen,
  1240.    which is supposed to be equivalent to nothing at all.
  1241.  
  1242.    If \ is followed by a null character, we return a negative
  1243.    value and leave the string pointer pointing at the null character.
  1244.  
  1245.    If \ is followed by 000, we return 0 and leave the string pointer
  1246.    after the zeros.  A value of 0 does not mean end of string.  */
  1247.  
  1248. int
  1249. parse_escape (string_ptr)
  1250.      char **string_ptr;
  1251. {
  1252.   register int c = *(*string_ptr)++;
  1253.   switch (c)
  1254.     {
  1255.     case 'a':
  1256.       return TARGET_BELL;
  1257.     case 'b':
  1258.       return TARGET_BS;
  1259.     case 'e':
  1260.       return 033;
  1261.     case 'f':
  1262.       return TARGET_FF;
  1263.     case 'n':
  1264.       return TARGET_NEWLINE;
  1265.     case 'r':
  1266.       return TARGET_CR;
  1267.     case 't':
  1268.       return TARGET_TAB;
  1269.     case 'v':
  1270.       return TARGET_VT;
  1271.     case '\n':
  1272.       return -2;
  1273.     case 0:
  1274.       (*string_ptr)--;
  1275.       return 0;
  1276.     case '^':
  1277.       c = *(*string_ptr)++;
  1278.       if (c == '\\')
  1279.     c = parse_escape (string_ptr);
  1280.       if (c == '?')
  1281.     return 0177;
  1282.       return (c & 0200) | (c & 037);
  1283.       
  1284.     case '0':
  1285.     case '1':
  1286.     case '2':
  1287.     case '3':
  1288.     case '4':
  1289.     case '5':
  1290.     case '6':
  1291.     case '7':
  1292.       {
  1293.     register int i = c - '0';
  1294.     register int count = 0;
  1295.     while (++count < 3)
  1296.       {
  1297.         c = *(*string_ptr)++;
  1298.         if (c >= '0' && c <= '7')
  1299.           i = (i << 3) + c - '0';
  1300.         else
  1301.           {
  1302.         (*string_ptr)--;
  1303.         break;
  1304.           }
  1305.       }
  1306.     if ((i & ~((1 << CHAR_TYPE_SIZE) - 1)) != 0)
  1307.       {
  1308.         i &= (1 << CHAR_TYPE_SIZE) - 1;
  1309.         warning ("octal character constant does not fit in a byte");
  1310.       }
  1311.     return i;
  1312.       }
  1313.     case 'x':
  1314.       {
  1315.     register int i = 0;
  1316.     register int count = 0;
  1317.     for (;;)
  1318.       {
  1319.         c = *(*string_ptr)++;
  1320.         if (c >= '0' && c <= '9')
  1321.           i = (i << 4) + c - '0';
  1322.         else if (c >= 'a' && c <= 'f')
  1323.           i = (i << 4) + c - 'a' + 10;
  1324.         else if (c >= 'A' && c <= 'F')
  1325.           i = (i << 4) + c - 'A' + 10;
  1326.         else
  1327.           {
  1328.         (*string_ptr)--;
  1329.         break;
  1330.           }
  1331.       }
  1332.     if ((i & ~((1 << BITS_PER_UNIT) - 1)) != 0)
  1333.       {
  1334.         i &= (1 << BITS_PER_UNIT) - 1;
  1335.         warning ("hex character constant does not fit in a byte");
  1336.       }
  1337.     return i;
  1338.       }
  1339.     default:
  1340.       return c;
  1341.     }
  1342. }
  1343.  
  1344. void
  1345. yyerror (s)
  1346.      char *s;
  1347. {
  1348.   error (s);
  1349.   longjmp (parse_return_error, 1);
  1350. }
  1351.  
  1352. /* This page contains the entry point to this file.  */
  1353.  
  1354. /* Parse STRING as an expression, and complain if this fails
  1355.    to use up all of the contents of STRING.  */
  1356. /* We do not support C comments.  They should be removed before
  1357.    this function is called.  */
  1358.  
  1359. int
  1360. parse_c_expression (string)
  1361.      char *string;
  1362. {
  1363.   lexptr = string;
  1364.   
  1365.   if (lexptr == 0 || *lexptr == 0) {
  1366.     error ("empty #if expression");
  1367.     return 0;            /* don't include the #if group */
  1368.   }
  1369.  
  1370.   /* if there is some sort of scanning error, just return 0 and assume
  1371.      the parsing routine has printed an error message somewhere.
  1372.      there is surely a better thing to do than this.     */
  1373.   if (setjmp (parse_return_error))
  1374.     return 0;
  1375.  
  1376.   if (yyparse ())
  1377.     return 0;            /* actually this is never reached
  1378.                    the way things stand. */
  1379.   if (*lexptr)
  1380.     error ("Junk after end of expression.");
  1381.  
  1382.   return expression_value;    /* set by yyparse () */
  1383. }
  1384.  
  1385. #ifdef TEST_EXP_READER
  1386. /* main program, for testing purposes. */
  1387. main ()
  1388. {
  1389.   int n, c;
  1390.   char buf[1024];
  1391.   extern int yydebug;
  1392. /*
  1393.   yydebug = 1;
  1394. */
  1395.   initialize_random_junk ();
  1396.  
  1397.   for (;;) {
  1398.     printf ("enter expression: ");
  1399.     n = 0;
  1400.     while ((buf[n] = getchar ()) != '\n' && buf[n] != EOF)
  1401.       n++;
  1402.     if (buf[n] == EOF)
  1403.       break;
  1404.     buf[n] = '\0';
  1405.     printf ("parser returned %d\n", parse_c_expression (buf));
  1406.   }
  1407. }
  1408.  
  1409. /* table to tell if char can be part of a C identifier. */
  1410. unsigned char is_idchar[256];
  1411. /* table to tell if char can be first char of a c identifier. */
  1412. unsigned char is_idstart[256];
  1413. /* table to tell if c is horizontal space.  isspace () thinks that
  1414.    newline is space; this is not a good idea for this program. */
  1415. char is_hor_space[256];
  1416.  
  1417. /*
  1418.  * initialize random junk in the hash table and maybe other places
  1419.  */
  1420. initialize_random_junk ()
  1421. {
  1422.   register int i;
  1423.  
  1424.   /*
  1425.    * Set up is_idchar and is_idstart tables.  These should be
  1426.    * faster than saying (is_alpha (c) || c == '_'), etc.
  1427.    * Must do set up these things before calling any routines tthat
  1428.    * refer to them.
  1429.    */
  1430.   for (i = 'a'; i <= 'z'; i++) {
  1431.     ++is_idchar[i - 'a' + 'A'];
  1432.     ++is_idchar[i];
  1433.     ++is_idstart[i - 'a' + 'A'];
  1434.     ++is_idstart[i];
  1435.   }
  1436.   for (i = '0'; i <= '9'; i++)
  1437.     ++is_idchar[i];
  1438.   ++is_idchar['_'];
  1439.   ++is_idstart['_'];
  1440. #if DOLLARS_IN_IDENTIFIERS
  1441.   ++is_idchar['$'];
  1442.   ++is_idstart['$'];
  1443. #endif
  1444.  
  1445.   /* horizontal space table */
  1446.   ++is_hor_space[' '];
  1447.   ++is_hor_space['\t'];
  1448. }
  1449.  
  1450. error (msg)
  1451. {
  1452.   printf ("error: %s\n", msg);
  1453. }
  1454.  
  1455. warning (msg)
  1456. {
  1457.   printf ("warning: %s\n", msg);
  1458. }
  1459.  
  1460. struct hashnode *
  1461. lookup (name, len, hash)
  1462.      char *name;
  1463.      int len;
  1464.      int hash;
  1465. {
  1466.   return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
  1467. }
  1468. #endif
  1469.